import Vue from 'vue'
import * as api from '@/api/api'
import { isURL } from '@/utils/validate'
import { ACCESS_TOKEN } from '@/store/mutation-types'
import store from '../store'
import { getAction } from '../api/manage'
// import onlineCommons from '@jeecg/antd-online-mini'

export function timeFix() {
  const time = new Date()
  const hour = time.getHours()
  return hour < 9 ? '早上好' : hour <= 11 ? '上午好' : hour <= 13 ? '中午好' : hour < 20 ? '下午好' : '晚上好'
}

export function welcome() {
  const arr = ['休息一会儿吧', '准备吃什么呢?', '要不要打一把 DOTA', '我猜你可能累了']
  let index = Math.floor(Math.random() * arr.length)
  return arr[index]
}

/**
 * 触发 window.resize
 */
export function triggerWindowResizeEvent() {
  let event = document.createEvent('HTMLEvents')
  event.initEvent('resize', true, true)
  event.eventType = 'message'
  window.dispatchEvent(event)
}

/**
 * 过滤对象中为空的属性
 * @param obj
 * @returns {*}
 */
export function filterObj(obj) {
  if (!(typeof obj == 'object')) {
    return
  }

  for (let key in obj) {
    if (obj.hasOwnProperty(key) && (obj[key] == null || obj[key] == undefined || obj[key] === '')) {
      delete obj[key]
    }
  }
  return obj
}

/**
 * 时间格式化
 * @param value
 * @param fmt
 * @returns {*}
 */
export function formatDate(value, fmt) {
  let regPos = /^\d+(\.\d+)?$/
  if (regPos.test(value)) {
    //如果是数字
    let getDate = new Date(value)
    let o = {
      'M+': getDate.getMonth() + 1,
      'd+': getDate.getDate(),
      'h+': getDate.getHours(),
      'm+': getDate.getMinutes(),
      's+': getDate.getSeconds(),
      'q+': Math.floor((getDate.getMonth() + 3) / 3),
      S: getDate.getMilliseconds(),
    }
    if (/(y+)/.test(fmt)) {
      fmt = fmt.replace(RegExp.$1, (getDate.getFullYear() + '').substr(4 - RegExp.$1.length))
    }
    for (let k in o) {
      if (new RegExp('(' + k + ')').test(fmt)) {
        fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length))
      }
    }
    return fmt
  } else {
    //TODO
    value = value.trim()
    return value.substr(0, fmt.length)
  }
}

// 生成首页路由
export function generateIndexRouter(data) {
  let item = data[0]
  console.log('新的路由', item)
  let indexRouter = [
    {
      path: '/',
      name: 'dashboard',
      component: (resolve) => require(['@/components/layouts/TabLayout'], resolve),
      meta: { title: '首页' },
      redirect: item.path,
      children: [...generateChildRouters(data)],
    },
    {
      path: '*',
      redirect: '/404',
      hidden: true,
    },
  ]
  return indexRouter
}

// 生成嵌套路由（子路由）

function generateChildRouters(data, appId) {
  const routers = []
  for (let item of data) {
    let component = ''
    if (item.component.indexOf('layouts') >= 0) {
      component = 'components/' + item.component
    } else {
      component = 'views/' + item.component
    }

    // eslint-disable-next-line
    let URL = (item.meta.url || '').replace(/{{([^}}]+)?}}/g, (s1, s2) => eval(s2)) // URL支持{{ window.xxx }}占位符变量
    if (isURL(URL)) {
      item.meta.url = URL
    }

    let componentPath
    /* if (item.component == 'modules/online/cgform/OnlCgformHeadList') {
      componentPath = onlineCommons.OnlCgformHeadList
    } else if (item.component == 'modules/online/cgform/OnlCgformCopyList') {
      componentPath = onlineCommons.OnlCgformCopyList
    } else if (item.component == 'modules/online/cgform/auto/OnlCgformAutoList') {
      componentPath = onlineCommons.OnlCgformAutoList
    } else if (item.component == 'modules/online/cgform/auto/OnlCgformTreeList') {
      componentPath = onlineCommons.OnlCgformTreeList
    } else if (item.component == 'modules/online/cgform/auto/erp/OnlCgformErpList') {
      componentPath = onlineCommons.OnlCgformErpList
    } else if (item.component == 'modules/online/cgform/auto/tab/OnlCgformTabList') {
      componentPath = onlineCommons.OnlCgformTabList
    } else if (item.component == 'modules/online/cgform/auto/innerTable/OnlCgformInnerTableList') {
      componentPath = onlineCommons.OnlCgformInnerTableList
    } else if (item.component == 'modules/online/cgreport/OnlCgreportHeadList') {
      componentPath = onlineCommons.OnlCgreportHeadList
    } else if (item.component == 'modules/online/cgreport/auto/OnlCgreportAutoList') {
      componentPath = onlineCommons.OnlCgreportAutoList
    } else { */
      componentPath = (resolve) => require(['@/' + component + '.vue'], resolve)
    // }

    let menu = {
      path: item.path,
      name: item.name,
      redirect: item.redirect,
      component: componentPath,
      //component: resolve => require(['@/' + component+'.vue'], resolve),
      hidden: item.hidden,
      //component:()=> import(`@/views/${item.component}.vue`),
      meta: {
        appId: appId || item.id,
        routeId: item.id,
        title: item.meta.title,
        icon: item.meta.icon,
        url: item.meta.url,
        permissionList: item.meta.permissionList,
        keepAlive: item.meta.keepAlive,
        /*update_begin author:wuxianquan date:20190908 for:赋值 */
        internalOrExternal: item.meta.internalOrExternal,
        /*update_end author:wuxianquan date:20190908 for:赋值 */
        componentName: item.meta.componentName,
      },
    }
    if (item.alwaysShow) {
      menu.alwaysShow = true
      // menu.redirect = menu.path;
    }
    if (item.children && item.children.length > 0) {
      menu.children = [...generateChildRouters(item.children, menu.meta.appId)]
    }
    //--update-begin----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
    //判断是否生成路由
    if (item.route && item.route === '0') {
      //console.log(' 不生成路由 item.route：  '+item.route);
      //console.log(' 不生成路由 item.path：  '+item.path);
    } else {
      routers.push(menu)
    }
    //--update-end----author:scott---date:20190320------for:根据后台菜单配置，判断是否路由菜单字段，动态选择是否生成路由（为了支持参数URL菜单）------
  }
  return routers
}

/**
 * 深度克隆对象、数组
 * @param obj 被克隆的对象
 * @return 克隆后的对象
 */
export function cloneObject(obj) {
  return JSON.parse(JSON.stringify(obj))
}

export function formatUrl(url) {
  //"http:///127.0.0.1:8082///jeecg-boot/sys/common/upload" => "http://127.0.0.1:8082/jeecg-boot/sys/common/upload"
  return url.replace(/(?<!:)\/\//gim, '/')
}

/**
 * 随机生成数字
 *
 * 示例：生成长度为 12 的随机数：randomNumber(12)
 * 示例：生成 3~23 之间的随机数：randomNumber(3, 23)
 *
 * @param1 最小值 | 长度
 * @param2 最大值
 * @return int 生成后的数字
 */
export function randomNumber() {
  // 生成 最小值 到 最大值 区间的随机数
  const random = (min, max) => {
    return Math.floor(Math.random() * (max - min + 1) + min)
  }
  if (arguments.length === 1) {
    let [length] = arguments
    // 生成指定长度的随机数字，首位一定不是 0
    let nums = [...Array(length).keys()].map((i) => (i > 0 ? random(0, 9) : random(1, 9)))
    return parseInt(nums.join(''))
  } else if (arguments.length >= 2) {
    let [min, max] = arguments
    return random(min, max)
  } else {
    return Number.NaN
  }
}

/**
 * 随机生成字符串
 * @param length 字符串的长度
 * @param chats 可选字符串区间（只会生成传入的字符串中的字符）
 * @return string 生成的字符串
 */
export function randomString(length, chats) {
  if (!length) length = 1
  if (!chats) chats = '0123456789qwertyuioplkjhgfdsazxcvbnm'
  let str = ''
  for (let i = 0; i < length; i++) {
    let num = randomNumber(0, chats.length - 1)
    str += chats[num]
  }
  return str
}

/**
 * 随机生成uuid
 * @return string 生成的uuid
 */
export function randomUUID() {
  let chats = '0123456789abcdef'
  return randomString(32, chats)
}

/**
 * 下划线转驼峰
 * @param string
 * @returns {*}
 */
export function underLine2CamelCase(string) {
  return string.replace(/_([a-z])/g, function (all, letter) {
    return letter.toUpperCase()
  })
}

/**
 * 驼峰转下划线
 * @param string
 * @returns {*}
 */
export function camelCase2UnderLine(string) {
  return string.replace(/([A-Z])/g, '_$1').toLowerCase()
}

/**
 * 判断是否显示办理按钮
 * @param bpmStatus
 * @returns {*}
 */
export function showDealBtn(bpmStatus) {
  if (bpmStatus != '1' && bpmStatus != '3' && bpmStatus != '4') {
    return true
  }
  return false
}

/**
 * 增强CSS，可以在页面上输出全局css
 * @param css 要增强的css
 * @param id style标签的id，可以用来清除旧样式
 */
export function cssExpand(css, id) {
  let style = document.createElement('style')
  style.type = 'text/css'
  style.innerHTML = `@charset "UTF-8"; ${css}`
  // 清除旧样式
  if (id) {
    let $style = document.getElementById(id)
    if ($style != null) $style.outerHTML = ''
    style.id = id
  }
  // 应用新样式
  document.head.appendChild(style)
}

/** 用于js增强事件，运行JS代码，可以传参 */
// options 所需参数：
//    参数名         类型            说明
//    vm             VueComponent    vue实例
//    event          Object          event对象
//    jsCode         String          待执行的js代码
//    errorMessage   String          执行出错后的提示（控制台）
export function jsExpand(options = {}) {
  // 绑定到window上的keyName
  let windowKeyName = 'J_CLICK_EVENT_OPTIONS'
  if (typeof window[windowKeyName] != 'object') {
    window[windowKeyName] = {}
  }

  // 随机生成JS增强的执行id，防止冲突
  let id = randomString(16, 'qwertyuioplkjhgfdsazxcvbnm'.toUpperCase())
  // 封装按钮点击事件
  let code = `
    (function (o_${id}) {
      try {
        (function (globalEvent, vm) {
          ${options.jsCode}
        })(o_${id}.event, o_${id}.vm)
      } catch (e) {
        o_${id}.error(e)
      }
      o_${id}.done()
    })(window['${windowKeyName}']['EVENT_${id}'])
  `
  // 创建script标签
  const script = document.createElement('script')
  // 将需要传递的参数挂载到window对象上
  window[windowKeyName]['EVENT_' + id] = {
    vm: options.vm,
    event: options.event,
    // 当执行完成时，无论如何都会调用的回调事件
    done() {
      // 执行完后删除新增的 script 标签不会撤销执行结果（已产生的结果不会被撤销）
      script.outerHTML = ''
      delete window[windowKeyName]['EVENT_' + id]
    },
    // 当js运行出错的时候调用的事件
    error(e) {
      console.group(`${options.errorMessage || '用户自定义JS增强代码运行出错'}（${new Date()}）`)
      console.error(e)
      console.groupEnd()
    },
  }
  // 将事件挂载到document中
  script.innerHTML = code
  document.body.appendChild(script)
}

/**
 * 重复值验证工具方法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateDuplicateValue('sys_fill_rule', 'rule_code', value, this.model.id, callback) }
 *
 * @param tableName 被验证的表名
 * @param fieldName 被验证的字段名
 * @param fieldVal 被验证的值
 * @param dataId 数据ID，可空
 * @param callback
 */
export function validateDuplicateValue(tableName, fieldName, fieldVal, dataId, callback) {
  if (fieldVal) {
    let params = { tableName, fieldName, fieldVal, dataId }
    console.log('验证重复值：', params)
    api
      .duplicateCheck(params)
      .then((res) => {
        res['success'] ? callback() : callback(res['message'])
      })
      .catch((err) => {
        // callback(err.message || err)
      })
  } else {
    callback()
  }
}

/**
 * 根据编码校验规则code，校验传入的值是否合法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateCheckRule('common', value, callback) }
 *
 * @param ruleCode 编码校验规则 code
 * @param value 被验证的值
 * @param callback
 */
export function validateCheckRule(ruleCode, value, callback) {
  if (ruleCode && value) {
    value = encodeURIComponent(value)
    api
      .checkRuleByCode({ ruleCode, value })
      .then((res) => {
        res['success'] ? callback() : callback(res['message'])
      })
      .catch((err) => {
        callback(err.message || err)
      })
  } else {
    callback()
  }
}

/**
 * 如果值不存在就 push 进数组，反之不处理
 * @param array 要操作的数据
 * @param value 要添加的值
 * @param key 可空，如果比较的是对象，可能存在地址不一样但值实际上是一样的情况，可以传此字段判断对象中唯一的字段，例如 id。不传则直接比较实际值
 * @returns {boolean} 成功 push 返回 true，不处理返回 false
 */
export function pushIfNotExist(array, value, key) {
  for (let item of array) {
    if (key && item[key] === value[key]) {
      return false
    } else if (item === value) {
      return false
    }
  }
  array.push(value)
  return true
}

/**
 * 可用于判断是否成功
 * @type {symbol}
 */
export const succeedSymbol = Symbol()
/**
 * 可用于判断是否失败
 * @type {symbol}
 */
export const failedSymbol = Symbol()

/**
 * 使 promise 无论如何都会 resolve，除非传入的参数不是一个Promise对象或返回Promise对象的方法
 * 一般用在 Promise.all 中
 *
 * @param promise 可传Promise对象或返回Promise对象的方法
 * @returns {Promise<any>}
 */
export function alwaysResolve(promise) {
  return new Promise((resolve, reject) => {
    let p = promise
    if (typeof promise === 'function') {
      p = promise()
    }
    if (p instanceof Promise) {
      p.then((data) => {
        resolve({ type: succeedSymbol, data })
      }).catch((error) => {
        resolve({ type: failedSymbol, error })
      })
    } else {
      reject('alwaysResolve: 传入的参数不是一个Promise对象或返回Promise对象的方法')
    }
  })
}

/**
 * 简单实现防抖方法
 *
 * 防抖(debounce)函数在第一次触发给定的函数时，不立即执行函数，而是给出一个期限值(delay)，比如100ms。
 * 如果100ms内再次执行函数，就重新开始计时，直到计时结束后再真正执行函数。
 * 这样做的好处是如果短时间内大量触发同一事件，只会执行一次函数。
 *
 * @param fn 要防抖的函数
 * @param delay 防抖的毫秒数
 * @returns {Function}
 */
export function simpleDebounce(fn, delay = 100) {
  let timer = null
  return function () {
    let args = arguments
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(() => {
      fn.apply(this, args)
    }, delay)
  }
}
/*金额处理*/
export function clearNoNum(value) {
  //先把非数字的都替换掉，除了数字和.
  value = value.replace(/[^\d.]/g, '')
  //保证只有出现一个.而没有多个.
  value = value.replace(/\.{2,}/g, '.')
  //必须保证第一个为数字而不是.
  value = value.replace(/^\./g, '')
  //保证.只出现一次，而不能出现两次以上
  value = value.replace('.', '$#$').replace(/\./g, '').replace('$#$', '.')
  //只能输入四个小数
  value = value.replace(/^(\-)*(\d+)\.(\d\d\d\d).*$/, '$1$2.$3')
  // console.log(value.includes('.'),'wwwwww')
  //小数位处理
  if (value.substring(0, 1) == '0' && value.substring(0, 2) != '0.') {
    value = '0'
  }

  //输入长度控制
  if (value > 999999999999.9999) {
    value = value.slice(0, 12)
  }

  return value
}
/*金额处理2位小数*/
export function checkPrice(value) {
  //先把非数字的都替换掉，除了数字和.
  value = value.replace(/[^\d.]/g, '')
  //保证只有出现一个.而没有多个.
  value = value.replace(/\.{2,}/g, '.')
  //必须保证第一个为数字而不是.
  value = value.replace(/^\./g, '')
  //保证.只出现一次，而不能出现两次以上
  value = value.replace('.', '$#$').replace(/\./g, '').replace('$#$', '.')
  //只能输入四个小数
  value = value.replace(/^(\-)*(\d+)\.(\d\d).*$/, '$1$2.$3')
  // console.log(value.includes('.'),'wwwwww')
  //小数位处理
  if (value.substring(0, 1) == '0' && value.substring(0, 2) != '0.') {
    value = '0'
  }
  //输入长度控制
  if (value > 99999999999999.99) {
    value = 99999999999999.99
  }

  return value
}
/*金额处理2位小数（允许负数)*/
export function clearPrice(value) {
  //先把非数字的都替换掉，除了数字和.
  value = value.replace(/[^\d.-]/g, '')
  //保证只有出现一个.而没有多个.
  value = value.replace(/\.{2,}/g, '.')
  value = value.replace(/^\./g, '')
  //保证.只出现一次，而不能出现两次以上
  value = value.replace('.', '$#$').replace(/\./g, '').replace('$#$', '.')
  value = value.replace('-', '$#$').replace(/\-/g, '').replace('$#$', '-')
  value = value.replace(/^(\-)*(\d+)\.(\d\d).*$/, '$1$2.$3')
  if (value.substring(0, 1) == '0' && value.substring(0, 2) != '0.') {
    value = '0'
  }
  //输入长度控制
  if (value > 99999999999999.99) {
    value = 99999999999999.99
  }

  return value
}

/*数字转千分位方法不带两位小数 */
export function numFormat(num) {
  if ((num + '').trim() == '') {
    return ''
  }
  if (isNaN(num)) {
    return ''
  }
  num = Number(num)
  num = num + ''

  if (/^.*\..*$/.test(num)) {
    var pointIndex = num.lastIndexOf('.')
    var intPart = num.substring(0, pointIndex)
    var pointPart = num.substring(pointIndex + 1, num.length)
    intPart = intPart + ''
    var re = /(-?\d+)(\d{3})/
    while (re.test(intPart)) {
      intPart = intPart.replace(re, '$1,$2')
    }
    num = intPart + '.' + pointPart
  } else {
    num = num + ''
    var re = /(-?\d+)(\d{3})/
    while (re.test(num)) {
      num = num.replace(re, '$1,$2')
    }
  }

  return num
}

/*数字转千分位方法带四位小数 */
export function commafyTofixed(num, float) {
  if ((num + '').trim() == '') {
    return ''
  }
  if (isNaN(num)) {
    return ''
  }
  var flo = float ? float : 4
  num = Number(num).toFixed(flo)
  num = num + ''

  if (/^.*\..*$/.test(num)) {
    var pointIndex = num.lastIndexOf('.')
    var intPart = num.substring(0, pointIndex)
    var pointPart = num.substring(pointIndex + 1, num.length)
    intPart = intPart + ''
    var re = /(-?\d+)(\d{3})/
    while (re.test(intPart)) {
      intPart = intPart.replace(re, '$1,$2')
    }
    num = intPart + '.' + pointPart
  } else {
    num = num + ''
    var re = /(-?\d+)(\d{3})/
    while (re.test(num)) {
      num = num.replace(re, '$1,$2')
    }
  }

  return num
}
/*数字转千分位方法带2位小数 */
export function commafyTofixedTwo(num, float) {
  if ((num + '').trim() == '') {
    return ''
  }
  if (isNaN(num)) {
    return ''
  }
  var flo = float ? float : 2
  num = Number(num).toFixed(flo)
  num = num + ''

  if (/^.*\..*$/.test(num)) {
    var pointIndex = num.lastIndexOf('.')
    var intPart = num.substring(0, pointIndex)
    var pointPart = num.substring(pointIndex + 1, num.length)
    intPart = intPart + ''
    var re = /(-?\d+)(\d{3})/
    while (re.test(intPart)) {
      intPart = intPart.replace(re, '$1,$2')
    }
    num = intPart + '.' + pointPart
  } else {
    num = num + ''
    var re = /(-?\d+)(\d{3})/
    while (re.test(num)) {
      num = num.replace(re, '$1,$2')
    }
  }

  return num
}

/**
 * 不用正则的方式替换所有值
 * @param text 被替换的字符串
 * @param checker  替换前的内容
 * @param replacer 替换后的内容
 * @returns {String} 替换后的字符串
 */
export function replaceAll(text, checker, replacer) {
  let lastText = text
  text = text.replace(checker, replacer)
  if (lastText !== text) {
    return replaceAll(text, checker, replacer)
  }
  return text
}

/**
 * 获取事件冒泡路径，兼容 IE11，Edge，Chrome，Firefox，Safari
 * 目前使用的地方：JEditableTable Span模式
 */
export function getEventPath(event) {
  let target = event.target
  let path = (event.composedPath && event.composedPath()) || event.path

  if (path != null) {
    return path.indexOf(window) < 0 ? path.concat(window) : path
  }

  if (target === window) {
    return [window]
  }

  let getParents = (node, memo) => {
    memo = memo || []
    const parentNode = node.parentNode

    if (!parentNode) {
      return memo
    } else {
      return getParents(parentNode, memo.concat(parentNode))
    }
  }
  return [target].concat(getParents(target), window)
}

/**
 * 根据组件名获取父级
 * @param vm
 * @param name
 * @returns {Vue | null|null|Vue}
 */
export function getVmParentByName(vm, name) {
  let parent = vm.$parent
  if (parent && parent.$options) {
    if (parent.$options.name === name) {
      return parent
    } else {
      let res = getVmParentByName(parent, name)
      if (res) {
        return res
      }
    }
  }
  return null
}

/**
 * 使一个值永远不会为（null | undefined）
 *
 * @param value 要处理的值
 * @param def 默认值，如果value为（null | undefined）则返回的默认值，可不传，默认为''
 */
export function neverNull(value, def) {
  return value == null ? neverNull(def, '') : value
}

/**
 * 根据元素值移除数组中的一个元素
 * @param array 数组
 * @param prod 属性名
 * @param value 属性值
 * @returns {string}
 */
export function removeArrayElement(array, prod, value) {
  let index = -1
  for (let i = 0; i < array.length; i++) {
    if (array[i][prod] == value) {
      index = i
      break
    }
  }
  if (index >= 0) {
    array.splice(index, 1)
  }
}

/** 判断是否是OAuth2APP环境 */
export function isOAuth2AppEnv() {
  return /wxwork|dingtalk/i.test(navigator.userAgent)
}

/**
 * 获取积木报表打印地址
 * @param url
 * @param id
 * @param open 是否自动打开
 * @returns {*}
 */
export function getReportPrintUrl(url, id, open) {
  // URL支持{{ window.xxx }}占位符变量
  url = url.replace(/{{([^}]+)?}}/g, (s1, s2) => eval(s2))
  if (url.includes('?')) {
    url += '&'
  } else {
    url += '?'
  }
  url += `id=${id}`
  url += `&token=${Vue.ls.get(ACCESS_TOKEN)}`
  if (open) {
    window.open(url)
  }
  return url
}

/**
 * 重置列表
 * @param columns 列表默认拥有的所有列
 * @param checkedList 设置列选中的列
 * @param defaultItem 不参与设置列的列,一般为操作列,默认排在数组末尾(非必填)
 * @returns {Array}
 */
export function getNewColumns(columns, checkedList, defaultItem, current) {
  if (!checkedList) {
    return current.concat(defaultItem || [])
  }
  let newArr = []
  for (let j = 0; j < checkedList.length; j++) {
    for (let i = 0; i < columns.length; i++) {
      if (columns[i].dataIndex === checkedList[j].value) {
        columns[i].fixed = checkedList[j].isLock
        if (checkedList[j].width) {
          columns[i].width = checkedList[j].width
        }
        newArr.push(columns[i])
      }
    }
  }

  // newArr.concat(defaultItem || [])
  let currentColumn = newArr.concat(defaultItem || [])
  let arrThree = currentColumn.filter((item) => {
    return item.fixed == 'right'
  })
  let arrOne = currentColumn.filter((item) => {
    return item.fixed && item.fixed.toString() == 'true'
  })
  let arrTwo = currentColumn.filter((item) => {
    return !item.fixed || item.fixed == 'false'
  })
  let currntArr = [...arrOne, ...arrTwo, ...arrThree]
  return currntArr
}

/**
 * 列表信息格式化（超出长度显示...）
 * @param str 需要格式化的字符
 * @param length 需要显示的字符长度
 * @returns {String}
 */
export function subStrText(str, length) {
  let newStr = str
  if (str) {
    if (str.length > length) {
      newStr = str.substr(0, length)
      newStr += '...'
    }
  } else {
    newStr = '--'
  }
  return newStr
}

/* 匹配正整数 */
export function integerNum(value) {
  //先把非数字的都替换掉，除了数字0-9,
  value = value.replace(/[^0-9]/g, '')
  if (value.charAt(0) == 0) {
    value = ''
  }
  return value
}

/* 匹配正数,小数点后4位 */
export function fourFloatNum(value) {
  value = value + ''
  //先把非数字的都替换掉，除了数字和.,
  value = value.replace(/[^\d.]/g, '')
  value = value.replace(/^(\-)*(\d+)\.(\d{4}).*$/, '$1$2.$3')
  //小数位处理
  if (value.substring(0, 1) == '0' && value.substring(0, 2) != '0.') {
    value = '0'
  }
  return value
}

// 加法
export function accAdd(arg1, arg2) {
  var r1, r2, m, c
  try {
    r1 = arg1.toString().split('.')[1].length
  } catch (e) {
    r1 = 0
  }
  try {
    r2 = arg2.toString().split('.')[1].length
  } catch (e) {
    r2 = 0
  }
  c = Math.abs(r1 - r2)
  m = Math.pow(10, Math.max(r1, r2))
  if (c > 0) {
    var cm = Math.pow(10, c)
    if (r1 > r2) {
      arg1 = Number(arg1.toString().replace('.', ''))
      arg2 = Number(arg2.toString().replace('.', '')) * cm
    } else {
      arg1 = Number(arg1.toString().replace('.', '')) * cm
      arg2 = Number(arg2.toString().replace('.', ''))
    }
  } else {
    arg1 = Number(arg1.toString().replace('.', ''))
    arg2 = Number(arg2.toString().replace('.', ''))
  }
  return (arg1 + arg2) / m
}
// 减法
export function accSub(arg1, arg2) {
  var r1, r2, m, n
  try {
    r1 = arg1.toString().split('.')[1].length
  } catch (e) {
    r1 = 0
  }
  try {
    r2 = arg2.toString().split('.')[1].length
  } catch (e) {
    r2 = 0
  }
  m = Math.pow(10, Math.max(r1, r2)) //last modify by deeka //动态控制精度长度
  n = r1 >= r2 ? r1 : r2
  return ((arg1 * m - arg2 * m) / m).toFixed(n)
}
// 乘法
export function accMul(arg1, arg2) {
  var m = 0,
    s1 = arg1.toString(),
    s2 = arg2.toString()
  try {
    m += s1.split('.')[1].length
  } catch (e) {}
  try {
    m += s2.split('.')[1].length
  } catch (e) {}

  return (Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) / Math.pow(10, m)
}
// 除法
export function accDiv(arg1, arg2) {
  if (!arg1 && !arg2) {
    return 0
  }
  var t1 = 0,
    t2 = 0,
    r1,
    r2
  try {
    t1 = arg1.toString().split('.')[1].length
  } catch (e) {}
  try {
    t2 = arg2.toString().split('.')[1].length
  } catch (e) {}

  r1 = Number(arg1.toString().replace('.', ''))
  r2 = Number(arg2.toString().replace('.', ''))

  return (r1 / r2) * Math.pow(10, t2 - t1)
}
// 除法/保留4位小数
export function accDivMin(arg1, arg2) {
  var t1 = 0,
    t2 = 0,
    r1,
    r2,
    value
  try {
    t1 = arg1.toString().split('.')[1].length
  } catch (e) {}
  try {
    t2 = arg2.toString().split('.')[1].length
  } catch (e) {}

  r1 = Number(arg1.toString().replace('.', ''))
  r2 = Number(arg2.toString().replace('.', ''))
  value = (r1 / r2) * Math.pow(10, t2 - t1)
  value = value.toString().replace(/^(\-)*(\d+)\.(\d{4}).*$/, '$1$2.$3')
  return value
}
//比较时间大小
export function compareDate(date1, date2) {
  var oDate1 = new Date(date1)
  var oDate2 = new Date(date2)
  if (oDate1.getTime() > oDate2.getTime()) {
    return true //第一个大
  } else {
    return false //第二个大
  }
}
// 数字格式化，保留四位小数
export function changeDecimalBuZero(number, bitNum) {
  //number要处理的数字
  // bitNum生成的小数位数
  var f_x = parseFloat(number)
  if (isNaN(f_x)) {
    return 0
  }
  var s_x = number.toString()
  var pos_decimal = s_x.indexOf('.')
  if (pos_decimal < 0) {
    pos_decimal = s_x.length
    s_x += '.'
  }
  while (s_x.length <= pos_decimal + bitNum) {
    s_x += '0'
  }
  return s_x
}
//是否浏览器打开新tab页
export function openWay(that, isOpenNewTab, url, value) {
  //that  页面中的this
  //isOpenNewTab 是否打开浏览器新窗口 true为是；false为否
  //url  路由地址
  //value  传递参数value,格式为对象
  if (value) {
    that.$router.push({
      path: url,
      query: value,
    })
  } else {
    this.$router.push({
      path: url,
    })
  }
  return
  let currentEnvironment = sessionStorage.getItem('currentEnvironment')
  if (currentEnvironment == 'browser') {
    if (isOpenNewTab) {
      if (value) {
        let routeUrl = that.$router.resolve({
          path: url,
          query: value,
        })
        window.open(routeUrl.href, '_blank')
      } else {
        let routeUrl = that.$router.resolve({
          path: url,
        })
        window.open(routeUrl.href, '_blank')
      }
    } else {
      if (value) {
        that.$router.push({
          path: url,
          query: value,
        })
      } else {
        this.$router.push({
          path: url,
        })
      }
    }
  } else {
    if (value) {
      that.$router.push({
        path: url,
        query: value,
      })
    } else {
      this.$router.push({
        path: url,
      })
    }
  }
}
// 获取数组key
export function getObjectKeys(object) {
  var keys = []
  for (var property in object) keys.push(property)
  return keys
}
// 获取数组value
export function getObjectValues(object) {
  var values = []
  for (var property in object) values.push(object[property])
  return values
}

// 生成数组
export function getArr(a, b) {
  let arr = []
  for (let i = 0; i < a.length; i++) {
    if (b[i] || b[i] === 0) {
      arr.push({
        key: a[i],
        value: b[i],
      })
    }
  }
  return arr
}
// 生成筛选后数组
export function getList(a, b) {
  let arr = []
  for (let i = 0; i < a.length; i++) {
    for (let j = 0; j < b.length; j++) {
      if (a[i].key == b[j].searchIndex) {
        if (b[j].scopedSlots.filterDropdown === 'selectDropdown') {
          let val = a.find((e) => {
            return e.key == `${b[j].searchIndex}all`
          }).value
          if (val && Array.isArray(val)) {
            arr.push({
              title: b[j].title,
              value: val
                .map((e) => {
                  return e.label
                })
                .toString(),
              key: b[j].searchIndex,
              type: 0,
              multi: true,
            })
          } else if (val) {
            arr.push({
              title: b[j].title,
              value: val.label,
              key: b[j].searchIndex,
              type: 0,
              multi: false,
            })
          }
        } else if (
          b[j].scopedSlots.filterDropdown.includes('selectPeople') ||
          b[j].scopedSlots.filterDropdown === 'sendPersion' ||
          b[j].scopedSlots.filterDropdown === 'updateBy' ||
          b[j].scopedSlots.filterDropdown === 'createBy'
        ) {
          // 适应多个表头人员筛选问题
          let val = a.find((e) => {
            return e.key == `${b[j].searchIndex}realname`
          }).value
          if (val) {
            arr.push({
              title: b[j].title,
              value: val,
              key: b[j].searchIndex,
              type: 1,
            })
          }
        } else if (b[j].scopedSlots.filterDropdown === 'selectProcess') {
          let val = a.find((e) => {
            return e.key == `${b[j].searchIndex}Text`
          }).value
          if (val) {
            arr.push({
              title: b[j].title,
              value: val,
              key: b[j].searchIndex,
              type: 1,
            })
          }
        } else if (b[j].scopedSlots.filterDropdown === 'selectDropdownTree') {
          console.log(a, b, i, j)
          if (a[i].value && a[i].value.length > 0) {
            arr.push({
              title: b[j].title,
              value: a[1].value,
              key: b[j].searchIndex,
              type: 4,
            })
          }
        } else {
          if (a[i].value && a[i].value.length > 0) {
            arr.push({
              title: b[j].title,
              value: Array.isArray(a[i].value) ? a[i].value.toString() : a[i].value,
              key: b[j].searchIndex,
              type: Array.isArray(a[i].value) ? 2 : 3,
            })
          }
        }
      }
    }
  }
  return arr
}

// 金额单位计算
export function amountUnit(v) {
  let num = v.toString()
  let amountUnitText = ''
  const newArr = ['百', '千', '万', '十万', '百万', '千万', '亿', '十亿', '百亿', '千亿']
  if (!num) {
    amountUnitText = ''
  } else {
    let newNum = num.split('.')
    let newNumLen = newNum[0].length
    if (newNumLen >= 3) {
      amountUnitText = newArr[newNumLen - 3]
    }
  }
  return amountUnitText
}

//对象数组利用id去重
export function objArrFilter(tempArr) {
  let result = []
  let obj = {}
  for (let i = 0; i < tempArr.length; i++) {
    if (!obj[tempArr[i].id]) {
      result.push(tempArr[i])
      obj[tempArr[i].id] = true
    }
  }
  return result
}

/**
 * 校验部门名称是否唯一
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateCheckCode(value, callback) }
 *
 * @param fieldVal 被验证的值
 * @param queryId 编辑id
 * @param parentId 父级id
 * @param callback
 */
export function validateCheckCode(fieldVal, queryId, parentId, callback) {
  let tenantId = store.state.user.tenantid
  if (fieldVal) {
    let params = {
      name: fieldVal,
      tenantId,
      queryId,
      parentId,
      // tenantId: userInfo.tenantId
    }
    getAction('/sys/sysDepart/checkCode', params)
      .then((res) => {
        // res['success'] ? callback() : callback(res['message'])
        if (!res['success']) {
          this.$antdMessage.error(res['message'])
        }
        callback()
      })
      .catch((err) => {
        callback()
        // callback(err.message || err)
      })
  } else {
    callback()
  }
}

/**
 * 所有租户下的账号不可重复
 *
 * 使用示例：
 * { validator: (phone, callback) => validateCheckRule('13812341234', callback) }
 *
 * @param userName 编码校验规则 phone
 * @param queryId 数据ID，可空
 * @param callback
 */
export function validateCheckUserNameRule(userName, queryId, callback) {
  if (userName) {
    getAction('/sys/user/checkUserName', { userName, queryId })
      .then((res) => {
        res['success'] ? callback() : callback(res['message'])
      })
      .catch((err) => {
        callback(err.message || err)
      })
  } else {
    callback()
  }
}

/**
 * 用户手机号是否可用
 *
 * 使用示例：
 * { validator: (phone, callback) => validateCheckRule('13812341234', callback) }
 *
 * @param phone 编码校验规则 phone
 * @param queryId 数据ID，可空
 * @param callback
 */
export function validateCheckUserPhoneRule(phone, queryId, callback) {
  let tenantId = store.state.user.tenantid
  if (phone) {
    getAction('/sys/user/checkPhone', { phone, queryId, tenantId })
      .then((res) => {
        res['success'] ? callback() : callback(res['message'])
      })
      .catch((err) => {
        callback(err.message || err)
      })
  } else {
    callback()
  }
}

/**
 * 角色编号重复值验证工具方法
 *
 * 使用示例：
 * { validator: (rule, value, callback) => validateDuplicateRoleValue(value, tenantId, this.model.id, callback) }
 *
 * @param roleCode 编号
 * @param tenantId 所属租户Id
 * @param queryId 数据ID，可空
 * @param callback
 */
export function validateDuplicateRoleValue(roleCode, tenantId, queryId, callback) {
  if (tenantId && roleCode) {
    let params = { roleCode, tenantId, queryId }
    getAction('/sys/role/checkRoleCode', params)
      .then((res) => {
        res['success'] ? callback() : callback(res['message'])
      })
      .catch((err) => {
        callback(err.message || err)
      })
  } else {
    callback()
  }
}
export function getNewColumnsDx(columns, checkedList, defaultItem) {
  if (!checkedList) {
    return columns.concat(defaultItem || [])
  }
  let newArr = []
  for (let j = 0; j < checkedList.length; j++) {
    for (let i = 0; i < columns.length; i++) {
      if (columns[i].dataIndex === checkedList[j].value) {
        columns[i].fixed = checkedList[j].isLock
        if (checkedList[j].width) {
          columns[i].width = checkedList[j].width
        }
        newArr.push(columns[i])
      }
    }
  }

  // newArr.concat(defaultItem || [])
  let currentColumn = newArr.concat(defaultItem || [])
  let arrThree = currentColumn.filter((item) => {
    return item.fixed == 'right'
  })
  let arrOne = currentColumn.filter((item) => {
    return item.fixed && item.fixed.toString() == 'true'
  })
  let arrTwo = currentColumn.filter((item) => {
    return !item.fixed || item.fixed == 'false'
  })
  let currntArr = [...arrOne, ...arrTwo, ...arrThree]
  return currntArr
}

// 自定义字段-筛选数据处理
export function stringToObject(param) {
  for (const key in param) {
    if (Object.hasOwnProperty.call(param, key)) {
      const value = param[key]
      let keys = key.split('.')
      if (keys.length > 1) {
        if (param[keys[0]]) {
          param[keys[0]][keys[1]] = value
        } else {
          param[keys[0]] = {}
          param[keys[0]][keys[1]] = value
        }
      }
    }
  }
  return param
}
